A correspondence between rooted planar maps and normal planar lambda terms

A rooted planar map is a connected graph embedded in the 2-sphere, with one edge marked and assigned an orientation. A term of the pure lambda calculus is said to be linear if every variable is used exactly once, normal if it contains no beta-redexes, and planar if it is linear and the use of variables moreover follows a deterministic stack discipline. We begin by showing that the sequence counting normal planar lambda terms by a natural notion of size coincides with the sequence (originally computed by Tutte) counting rooted planar maps by number of edges. Next, we explain how to apply the machinery of string diagrams to derive a graphical language for normal planar lambda terms, extracted from the semantics of linear lambda calculus in symmetric monoidal closed categories equipped with a linear reflexive object or a linear reflexive pair. Finally, our main result is a size-preserving bijection between rooted planar maps and normal planar lambda terms, which we establish by explaining how Tutte decomposition of rooted planar maps (into vertex maps, maps with an isthmic root, and maps with a non-isthmic root) may be naturally replayed in linear lambda calculus, as certain surgeries on the string diagrams of normal planar lambda terms.Comment: Corrected title field in metadat

Enumeration of Hypermaps of a Given Genus

This paper addresses the enumeration of rooted and unrooted hypermaps of a given genus. For rooted hypermaps the enumeration method consists of considering the more general family of multirooted hypermaps, in which darts other than the root dart are distinguished. We give functional equations for the generating series counting multirooted hypermaps of a given genus by number of darts, vertices, edges, faces and the degrees of the vertices containing the distinguished darts. We solve these equations to get parametric expressions of the generating functions of rooted hypermaps of low genus. We also count unrooted hypermaps of given genus by number of darts, vertices, hyperedges and faces.Comment: 42 page

A Symbolic Transformation Language and its Application to a Multiscale Method

The context of this work is the design of a software, called MEMSALab, dedicated to the automatic derivation of multiscale models of arrays of micro- and nanosystems. In this domain a model is a partial differential equation. Multiscale methods approximate it by another partial differential equation which can be numerically simulated in a reasonable time. The challenge consists in taking into account a wide range of geometries combining thin and periodic structures with the possibility of multiple nested scales. In this paper we present a transformation language that will make the development of MEMSALab more feasible. It is proposed as a Maple package for rule-based programming, rewriting strategies and their combination with standard Maple code. We illustrate the practical interest of this language by using it to encode two examples of multiscale derivations, namely the two-scale limit of the derivative operator and the two-scale model of the stationary heat equation.Comment: 36 page

Graph Based Reduction of Program Verification Conditions

Increasing the automaticity of proofs in deductive verification of C programs is a challenging task. When applied to industrial C programs known heuristics to generate simpler verification conditions are not efficient enough. This is mainly due to their size and a high number of irrelevant hypotheses. This work presents a strategy to reduce program verification conditions by selecting their relevant hypotheses. The relevance of a hypothesis is determined by the combination of a syntactic analysis and two graph traversals. The first graph is labeled by constants and the second one by the predicates in the axioms. The approach is applied on a benchmark arising in industrial program verification

Quantum contextual finite geometries from dessins d'enfants

We point out an explicit connection between graphs drawn on compact Riemann surfaces defined over the field $\bar{\mathbb{Q}}$ of algebraic numbers --- so-called Grothendieck's {\it dessins d'enfants} --- and a wealth of distinguished point-line configurations. These include simplices, cross-polytopes, several notable projective configurations, a number of multipartite graphs and some 'exotic' geometries. Among them, remarkably, we find not only those underlying Mermin's magic square and magic pentagram, but also those related to the geometry of two- and three-qubit Pauli groups. Of particular interest is the occurrence of all the three types of slim generalized quadrangles, namely GQ(2,1), GQ(2,2) and GQ(2,4), and a couple of closely related graphs, namely the Schl\"{a}fli and Clebsch ones. These findings seem to indicate that {\it dessins d'enfants} may provide us with a new powerful tool for gaining deeper insight into the nature of finite-dimensional Hilbert spaces and their associated groups, with a special emphasis on contextuality.Comment: 18 page

Un programme annoté en vaut deux

National audienceFormal verification methods could be of much help to increase software safety. But how to transfer these methods in the real world of critical software development? This paper proposes a tooled solution for source code verification, by automated reduction of safety properties into formal assertions. This approach is applied to JML annotated Java programs. It is illustrated by the automated generation of assertions for a class from the Java Card API. Two complementary formalisms are proposed for expressing properties. Their reduction in JML annotations is implanted in the JAG tool, described with details. The output language (JML) being standard, this tool interfaces easily with many standard tools for verification of JML/Java code by proof ou model-checking.La sécurité du logiciel passe par les méthodes formelles, mais comment faire passer les méthodes formelles dans le monde réel du développement des logiciels critiques ? Cet article propose un mécanisme et un outil d'aide à la vérification de code, par réduction automatique de propriétés de sécurité en annotations formelles. Ce dispositif s'applique aux programmes Java annotés en JML. Il est illustré ici par l'annotation automatique d'une classe de l'API Java Card. Deux formalismes complémentaires pour l'expression de propriétés sont proposés. L'outil JAG, qui implante leur réduction en annotations JML, est décrit en détail. Le langage d'annotations retenu (JML) étant standard, cet outil s'interface naturellement avec de nombreux outils existants pour la vérification par preuve, test ou model-checking de Java annoté en JML

Simulations for a Class of Two-Dimensional Automata

We study the notion of simulation over a class of automata which recognize 2D languages (languages of arrays of letters). This class of two-dimensional On-line Tessellation Automata (2OTA) accepts the same class of languages as the class of tiling systems, considered as the natural extension of classical regular word languages to the 2D case. We prove that simulation over 2OTA implies language inclusion. Even if the existence of a simulation relation between two 2OTA is shown to be an NP-complete problem in time, this is an important result since the inclusion problem is undecidable in general in this class of languages. Then we prove the existence in a given 2OTA of a unique maximal autosimulation relation, computable in polynomial time

Sequential generation of structured arrays and its deductive verification

International audienceA structured array is an array satisfying given constraints, such as being sorted or having no duplicate values. Generation of all arrays with a given structure up to some given length has many applications, including bounded exhaustive testing. A sequential generator of structured arrays can be defined by two C functions: the first one computes an initial array, and the second one steps from one array to the next one according to some total order on the set of arrays. We formally specify with ACSL annotations that the generated arrays satisfy the prescribed structural constraints (soundness property) and that the generation is in increasing lexicographic order (progress property). We refine this specification into two programming and specification patterns: one for generation in lexicographic order and one for generation by filtering the output of another generator. We distribute a library of generators instantiating these patterns. After adding suitable loop invariants we automatically prove the soundness and progress properties with the Frama-C platform

Specifying and Proving a Sorting Algorithm

Rapport de recherche LIFCThis work investigates the question of automaticity of algorithm proofs, through the typical example of a sorting algorithm. The first part introduces two specification languages for Java programs. In the second part one of them is used to specify a sorting algorithm by selection. The suggested specifications are enhanced until obtaining a complete solution by the current automated theorem provers. This report is a part of Elena Tushkanova's diploma project (equivalent to a master thesis) entitled “Modular Specification of Object Oriented Programs” from the Yaroslavl State University, Russia, translated from Russian into English